home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1996 #15 / Monster Media Number 15 (Monster Media)(July 1996).ISO / bbs_util / bsrc_260.zip / SRC.ZIP / HYDRA.C < prev    next >
C/C++ Source or Header  |  1996-02-20  |  62KB  |  2,277 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      ------------         Bit-Bucket Software, Co.                       */
  5. /*      \ 10001101 /         Writers and Distributors of                    */
  6. /*       \ 011110 /          Freely Available<tm> Software.                 */
  7. /*        \ 1011 /                                                          */
  8. /*         ------                                                           */
  9. /*                                                                          */
  10. /*              (C) Copyright 1987-96, Bit Bucket Software Co.              */
  11. /*                                                                          */
  12. /*              This module was contributed by Michael Buenter              */
  13. /*                   Based on original code by Arjen Lentz                  */
  14. /*                    HydraCom adaptation for BinkleyTerm                   */
  15. /*                                                                          */
  16. /*                                                                          */
  17. /*    For complete  details  of the licensing restrictions, please refer    */
  18. /*    to the License  agreement,  which  is published in its entirety in    */
  19. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.260.    */
  20. /*                                                                          */
  21. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  22. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  23. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  24. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  25. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  26. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  27. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  28. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  29. /*                                                                          */
  30. /*                                                                          */
  31. /* You can contact Bit Bucket Software Co. at any one of the following      */
  32. /* addresses:                                                               */
  33. /*                                                                          */
  34. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:343/491             */
  35. /* P.O. Box 460398                AlterNet 7:42/1491                        */
  36. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  37. /*                                Internet f491.n343.z1.fidonet.org         */
  38. /*                                                                          */
  39. /* Please feel free to contact us at any time to share your comments about  */
  40. /* our software and/or licensing policies.                                  */
  41. /*                                                                          */
  42. /*--------------------------------------------------------------------------*/
  43.  
  44. /*=============================================================================
  45.  
  46.                               HydraCom Version 1.08
  47.                              (+ rev. upto 18 dec 93)
  48.  
  49.                          A sample implementation of the
  50.                    HYDRA Bi-Directional File Transfer Protocol
  51.  
  52.                              HydraCom was written by
  53.                    Arjen G. Lentz, LENTZ SOFTWARE-DEVELOPMENT
  54.                   COPYRIGHT (C) 1991-1993; ALL RIGHTS RESERVED
  55.  
  56.                        The HYDRA protocol was designed by
  57.                  Arjen G. Lentz, LENTZ SOFTWARE-DEVELOPMENT and
  58.                             Joaquim H. Homrighausen
  59.                   COPYRIGHT (C) 1991-1993; ALL RIGHTS RESERVED
  60.  
  61.  
  62.   Revision history:
  63.   06 Sep 1991 - (AGL) First tryout
  64.   .. ... .... - Internal development
  65.   11 Jan 1993 - HydraCom version 1.00, Hydra revision 001 (01 Dec 1992)
  66.   13 Mar 1993 - HydraCom version 1.03, Hydra revision 001 (01 Dec 1992)
  67.   ..
  68.   Changes made by Michael Buenter:
  69.   03 Dec 1993 - adapted hydra for BT-EE and BT 2.58, many changes
  70.   ..
  71.   Updated source fixes by Arjen Lentz:
  72.   04 Sep 1993 - HydraCom version 1.08, Hydra revision 001 (01 Dec 1992)
  73.   23 Dec 1993 - updated to post-1.08 revisions upto 18 Dec 1993
  74.  
  75.   For complete details of the Hydra and HydraCom licensing restrictions,
  76.   please refer to the license agreements which are published in their entirety
  77.   in HYDRACOM.C and LICENSE.DOC, and also contained in the documentation file
  78.   HYDRACOM.DOC
  79.  
  80.   Use of this file is subject to the restrictions contained in the Hydra and
  81.   HydraCom licensing agreements. If you do not find the text of this agreement
  82.   in any of the aforementioned files, or if you do not have these files, you
  83.   should immediately contact LENTZ SOFTWARE-DEVELOPMENT and/or Joaquim
  84.   Homrighausen at one of the addresses listed below. In no event should you
  85.   proceed to use this file without having accepted the terms of the Hydra and
  86.   HydraCom licensing agreements, or such other agreement as you are able to
  87.   reach with LENTZ SOFTWARE-DEVELOMENT and Joaquim Homrighausen.
  88.  
  89.  
  90.   Hydra protocol design and HydraCom driver:         Hydra protocol design:
  91.   Arjen G. Lentz                                     Joaquim H. Homrighausen
  92.   LENTZ SOFTWARE-DEVELOPMENT                         389, route d'Arlon
  93.   Langegracht 7B                                     L-8011 Strassen
  94.   3811 BT  Amersfoort                                Luxembourg
  95.   The Netherlands
  96.   FidoNet 2:283/512, AINEX-BBS +31-33-633916         FidoNet 2:270/17
  97.   arjen_lentz@f512.n283.z2.fidonet.org               joho@ae.lu
  98.  
  99.   Please feel free to contact us at any time to share your comments about our
  100.   software and/or licensing policies.
  101.  
  102. =============================================================================*/
  103.  
  104. #include "includes.h"
  105. #include "hydra.h"
  106. #include "aglcrc.h"
  107.  
  108. /* external prototypes from janus.c */
  109. void j_status (char *,...);
  110. void j_msgend (word);
  111. void j_message (word, char *,...);
  112. int j_error (char *, char *);
  113. void xfer_summary (char *, char *, long *, int);
  114. void update_status (long *, long *, long, int *, int);
  115. long through (long *, long *);
  116.  
  117. int xfer_init (char *fname, long fsize, long ftime);
  118. int xfer_okay (void);
  119.  
  120. #define inteli(x) (x)
  121. #define intell(x) (x)
  122.  
  123. /* HYDRA's memory ---------------------------------------------------------- */
  124. static BOOL originator;                        /* are we the orig side?     */
  125. static int batchesdone;                        /* No. HYDRA batches done    */
  126. static BOOL hdxlink;                        /* hdx link & not orig side  */
  127. static ULONG options;                        /* INIT options hydra_init() */
  128. static word timeout;                        /* general timeout in secs   */
  129. static char abortstr[] =
  130. {24, 24, 24, 24, 24, 24, 24, 24, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 0};
  131.  
  132. #ifdef HYDRADEV
  133. static char *hdxmsg = "Fallback to one-way xfer";
  134.  
  135. #endif
  136. static char *pktprefix = "";
  137. static char *autostr = "hydra\r";
  138. static word *crc16tab;                        /* CRC-16 table              */
  139. static ULONG *crc32tab;                        /* CRC-32 table              */
  140. static char *GenericError = "!%s";
  141.  
  142. static byte *txbuf, *rxbuf;                    /* packet buffers            */
  143. static ULONG txoptions, rxoptions;            /* HYDRA options (INIT seq)  */
  144. static char txpktprefix[H_PKTPREFIX + 1];    /* pkt prefix str they want  */
  145. static long txwindow, rxwindow;                /* window size (0=streaming) */
  146. static h_timer braindead;                    /* braindead timer           */
  147. static byte *txbufin;                        /* read data from disk here  */
  148. static byte txlastc;                        /* last byte put in txbuf    */
  149. static byte rxdle;                            /* count of received H_DLEs  */
  150. static byte rxpktformat;                    /* format of pkt receiving   */
  151. static byte *rxbufptr;                        /* current position in rxbuf */
  152. static byte *rxbufmax;                        /* highwatermark of rxbuf    */
  153. static char txfname[13], rxfname[13];        /* fname of current files    */
  154. static char rxpathname[PATHLEN];            /* pathname of currrent file */
  155. static long txftime, rxftime;                /* file timestamp (UNIX)     */
  156. static long txfsize, rxfsize;                /* file length               */
  157. static int txfd, rxfd;                        /* file handles              */
  158. static word rxpktlen;                        /* length of last packet     */
  159. static word rxblklen;                        /* len of last good data blk */
  160. static int txstate, rxstate;                /* xmit/recv states          */
  161. static long txpos, rxpos;                    /* current position in files */
  162. static long txoldpos, rxoldpos;                /* last position in files    */
  163. static word txblklen;                        /* length of last block sent */
  164. static word txmaxblklen;                    /* max block length allowed  */
  165. static long txlastack;                        /* last dataack received     */
  166. static long txstart, rxstart;                /* time we started this file */
  167. static int txoldeta, rxoldeta;                /* last time needed          */
  168. static long txoffset, rxoffset;                /* offset in file we begun   */
  169. static h_timer txtimer, rxtimer;            /* retry timers              */
  170. static word txretries, rxretries;            /* retry counters            */
  171. static long rxlastsync;                        /* filepos last sync retry   */
  172. static long txsyncid, rxsyncid;                /* id of last resync         */
  173. static word txgoodneeded;                    /* to send before larger blk */
  174. static word txgoodbytes;                    /* no. sent at this blk size */
  175.  
  176. struct _h_flags
  177. {
  178.     char *str;
  179.     ULONG val;
  180. };
  181.  
  182. static struct _h_flags h_flags[] =
  183. {
  184.     {"XON", HOPT_XONXOFF},
  185.     {"TLN", HOPT_TELENET},
  186.     {"CTL", HOPT_CTLCHRS},
  187.     {"HIC", HOPT_HIGHCTL},
  188.     {"HI8", HOPT_HIGHBIT},
  189.     {"BRK", HOPT_CANBRK},
  190.     {"ASC", HOPT_CANASC},
  191.     {"UUE", HOPT_CANUUE},
  192.     {"C32", HOPT_CRC32},
  193.     {"DEV", HOPT_DEVICE},
  194.     {"FPT", HOPT_FPT},
  195.     {NULL, 0x0L}
  196. };
  197.  
  198. /*-------------------------------------------------------------------------*/
  199. static int Next_y;        /* Number of next available line on screen         */
  200. static int Tx_y;        /* Line number of file transmission status display */
  201. static int Rx_y;        /* Line number of file reception status display    */
  202.  
  203. static char *
  204. h_revdate (long revstamp)
  205. {
  206.     static char buf[12];
  207.     struct tm *t;
  208.  
  209.     t = localtime (&revstamp);
  210.     sprintf (buf, "%02d %s %d",
  211.         t->tm_mday, mtext[t->tm_mon], t->tm_year + 1900);
  212.  
  213.     return (buf);
  214. }                                            /*h_revdate()*/
  215.  
  216. #ifdef HYDRADEV
  217. /*---------------------------------------------------------------------------*/
  218. static void 
  219. hydra_msgdev (byte * data, word len)
  220. {                                /* text is already NUL terminated by calling func hydra_devrecv() */
  221.     len = len;
  222.     j_status ("*HMSGDEV: %s", data);
  223. }                                /*hydra_msgdev()*/
  224.  
  225. /*---------------------------------------------------------------------------*/
  226. static int devtxstate;                        /* dev xmit state            */
  227. static h_timer devtxtimer;                    /* dev xmit retry timer      */
  228. static word devtxretries;                    /* dev xmit retry counter    */
  229. static long devtxid, devrxid;                /* id of last devdata pkt    */
  230. static char devtxdev[H_FLAGLEN + 1];        /* xmit device ident flag    */
  231. static byte *devtxbuf;                        /* ptr to usersupplied dbuf  */
  232. static word devtxlen;                        /* len of data in xmit buf   */
  233.  
  234. struct _h_dev
  235. {
  236.     char *dev;
  237.     void (*func) (byte * data, word len);
  238. };
  239.  
  240. static struct _h_dev h_dev[] =
  241. {
  242.     {"MSG", hydra_msgdev},                    /* internal protocol msg     */
  243.     {"CON", NULL},                            /* text to console (chat)    */
  244.     {"PRN", NULL},                            /* data to printer           */
  245.     {"ERR", NULL},                            /* text to error output      */
  246.     {NULL, NULL}
  247. };
  248.  
  249. /*---------------------------------------------------------------------------*/
  250. BOOL 
  251. hydra_devfree (void)
  252. {
  253.     if (devtxstate || !(txoptions & HOPT_DEVICE) || txstate >= HTX_END)
  254.         return (FALSE);                        /* busy or not allowed       */
  255.     else
  256.         return (TRUE);                        /* allowed to send a new pkt */
  257. }                                            /*hydra_devfree()*/
  258.  
  259. /*---------------------------------------------------------------------------*/
  260. BOOL 
  261. hydra_devsend (char *dev, byte * data, word len)
  262. {
  263.     if (!dev || !data || !len || !hydra_devfree ())
  264.         return (FALSE);
  265.  
  266.     strncpy (devtxdev, dev, H_FLAGLEN);
  267.     devtxdev[H_FLAGLEN] = '\0';
  268.     strupr (devtxdev);
  269.     devtxbuf = data;
  270.     devtxlen = (len > H_MAXBLKLEN) ? H_MAXBLKLEN : len;
  271.  
  272.     devtxid++;
  273.     devtxtimer = h_timer_reset ();
  274.     devtxretries = 0;
  275.     devtxstate = HTD_DATA;
  276.  
  277.     return (TRUE);
  278. }                                            /*hydra_devsend()*/
  279.  
  280. /*---------------------------------------------------------------------------*/
  281. BOOL 
  282. hydra_devfunc (char *dev, void (*func) (byte * data, word len))
  283. {
  284.     register int i;
  285.  
  286.     for (i = 0; h_dev[i].dev; i++)
  287.     {
  288.         if (!strnicmp (dev, h_dev[i].dev, H_FLAGLEN))
  289.         {
  290.             h_dev[i].func = func;
  291.             return (TRUE);
  292.         }
  293.     }
  294.  
  295.     return (FALSE);
  296. }                                            /*hydra_devfunc()*/
  297.  
  298. /*---------------------------------------------------------------------------*/
  299. static void 
  300. hydra_devrecv (void)
  301. {
  302.     register char *p = (char *) rxbuf;
  303.     register int i;
  304.     word len = rxpktlen;
  305.  
  306.     p += (int) sizeof (long);                        /* skip the id long  */
  307.     len -= (int) sizeof (long);
  308.  
  309.     for (i = 0; h_dev[i].dev; i++)
  310.     {                                                /* walk through devs */
  311.         if (!strncmp (p, h_dev[i].dev, H_FLAGLEN))
  312.         {
  313.             if (h_dev[i].func)
  314.             {
  315.                 len -= ((int) strlen (p)) + 1;        /* sub devstr len    */
  316.                 p += ((int) strlen (p)) + 1;        /* skip devtag       */
  317.                 p[len] = '\0';                        /* NUL terminate     */
  318.                 (*h_dev[i].func) ((byte *) p, len);    /* call output func  */
  319.             }
  320.             break;
  321.         }
  322.     }
  323. }                                                    /*hydra_devrecv()*/
  324.  
  325. #endif
  326.  
  327. /*---------------------------------------------------------------------------*/
  328. int 
  329. xfer_init (char *fname, long fsize, long ftime)
  330. {
  331.     int i;
  332.     char namebuf[PATHLEN];
  333.  
  334.     Resume_WaZOO = 0;
  335.  
  336.     strcpy (rxpathname, remote_capabilities ? CURRENT.sc_Inbound : download_path);
  337.     strcat (rxpathname, fname);
  338.  
  339.     /*--------------------------------------------------------------------*/
  340.     /* Save info on WaZOO transfer in case of abort                       */
  341.     /*--------------------------------------------------------------------*/
  342.     if (remote_capabilities)
  343.     {
  344.         (void) strcpy (Resume_name, fname);
  345.         (void) sprintf (Resume_info, "%ld %lo", fsize, ftime);
  346.     }
  347.  
  348.     /*--------------------------------------------------------------------*/
  349.     /* Check if this is a failed WaZOO transfer which should be resumed   */
  350.     /*--------------------------------------------------------------------*/
  351.     if (remote_capabilities && dexists (Abortlog_name))
  352.     {
  353.         Resume_WaZOO = (byte) check_failed (Abortlog_name, fname, Resume_info, namebuf);
  354.     }
  355.  
  356.     if (Resume_WaZOO)
  357.     {
  358.         strcpy (rxpathname, CURRENT.sc_Inbound);
  359.         strcat (rxpathname, namebuf);
  360.     }
  361.     else
  362.     {
  363.         if (dexists (rxpathname))
  364.         {
  365.             struct stat f;
  366.  
  367.             stat (rxpathname, &f);
  368.             if (fsize == f.st_size && ftime == f.st_mtime)
  369.                 return (FALSE);    /* already have file */
  370.             else
  371.             {
  372.                 i = strlen (rxpathname) - 1;
  373.                 if ((!overwrite) || (is_arcmail (rxpathname, i)))
  374.                 {
  375.                     unique_name (rxpathname);
  376.                 }
  377.                 else
  378.                 {
  379.                     (void) unlink (rxpathname);
  380.                 }
  381.             }
  382.         }                                    /* if exist */
  383.     }                                        /* Resume_WaZOO */
  384.  
  385.     return (TRUE);
  386. }                                            /*xfer_init()*/
  387.  
  388. /*---------------------------------------------------------------------------*/
  389. int 
  390. xfer_okay (void)
  391. {
  392.     static char new_pathname[PATHLEN];
  393.     char *p;
  394.  
  395.     remove_abort (Abortlog_name, Resume_name);
  396.     strcpy (new_pathname, CURRENT.sc_Inbound);
  397.     p = new_pathname + ((int) strlen (new_pathname));    /* start of fname */
  398.     strcat (new_pathname, Resume_name);                    /* add real fname */
  399.     unique_name (new_pathname);                            /* make it unique */
  400.     if (rename (rxpathname, new_pathname))                /* rename temp to real */
  401.         status_line ("!Could not rename '%s' to '%s'", rxpathname, new_pathname);
  402.     strcpy (rxpathname, new_pathname);
  403.     return (stricmp (p, Resume_name));                    /* dup rename? */
  404. }
  405.  
  406. /*---------------------------------------------------------------------------*/
  407. static void 
  408. put_flags (char *buf, struct _h_flags flags[], long val)
  409. {
  410.     register char *p;
  411.     register int i;
  412.  
  413.     p = buf;
  414.     for (i = 0; flags[i].val; i++)
  415.     {
  416.         if (val & flags[i].val)
  417.         {
  418.             if (p > buf)
  419.                 *p++ = ',';
  420.             strcpy (p, flags[i].str);
  421.             p += H_FLAGLEN;
  422.         }
  423.     }
  424.     *p = '\0';
  425. }                                            /*put_flags()*/
  426.  
  427. /*---------------------------------------------------------------------------*/
  428. static ULONG 
  429. get_flags (char *buf, struct _h_flags flags[])
  430. {
  431.     register ULONG val;
  432.     register char *p;
  433.     register int i;
  434.  
  435.     val = 0x0L;
  436.     for (p = strtok (buf, ","); p; p = strtok (NULL, ","))
  437.     {
  438.         for (i = 0; flags[i].val; i++)
  439.         {
  440.             if (!strcmp (p, flags[i].str))
  441.             {
  442.                 val |= flags[i].val;
  443.                 break;
  444.             }
  445.         }
  446.     }
  447.     return (val);
  448. }                                            /*get_flags()*/
  449.  
  450. /*---------------------------------------------------------------------------*/
  451. /* CRC-16/32 code now separate source *//*AGL:10mar93*/
  452.  
  453. /*---------------------------------------------------------------------------*/
  454. static byte *
  455. put_binbyte (register byte * p, register byte c)
  456. {
  457.     register byte n;
  458.  
  459.     n = c;
  460.     if (txoptions & HOPT_HIGHCTL)
  461.         n &= 0x7f;
  462.  
  463.     if (n == H_DLE ||
  464.         ((txoptions & HOPT_XONXOFF) && (n == XON || n == XOFF)) ||
  465.         ((txoptions & HOPT_TELENET) && n == '\r' && txlastc == '@') ||
  466.         ((txoptions & HOPT_CTLCHRS) && (n < 32 || n == 127)))
  467.     {
  468.         *p++ = H_DLE;
  469.         c ^= 0x40;
  470.     }
  471.  
  472.     *p++ = c;
  473.     txlastc = n;
  474.  
  475.     return (p);
  476. }                                            /*put_binbyte()*/
  477.  
  478. /*---------------------------------------------------------------------------*/
  479. static void 
  480. txpkt (register word len, int type)
  481. {
  482.     register byte *in, *out;
  483.     register word c, n;
  484.     BOOL crc32 = FALSE;
  485.     byte format;
  486.     static char hexdigit[] = "0123456789abcdef";
  487.  
  488.     txbufin[len++] = (byte)type;
  489.  
  490.     switch (type)
  491.     {
  492.     case HPKT_START:
  493.     case HPKT_INIT:
  494.     case HPKT_INITACK:
  495.     case HPKT_END:
  496.     case HPKT_IDLE:
  497.         format = HCHR_HEXPKT;
  498.         break;
  499.  
  500.     default:
  501.         /* COULD do smart format selection depending on data and options! */
  502.         if (txoptions & HOPT_HIGHBIT)
  503.         {
  504.             if ((txoptions & HOPT_CTLCHRS) && (txoptions & HOPT_CANUUE))
  505.                 format = HCHR_UUEPKT;
  506.             else if (txoptions & HOPT_CANASC)
  507.                 format = HCHR_ASCPKT;
  508.             else
  509.                 format = HCHR_HEXPKT;
  510.         }
  511.         else
  512.             format = HCHR_BINPKT;
  513.         break;
  514.     }
  515.  
  516.     if (format != HCHR_HEXPKT && (txoptions & HOPT_CRC32))
  517.         crc32 = TRUE;
  518.  
  519. #ifdef DEBUG
  520.     if (debugging_log)
  521.     {
  522.         char *s1, *s2, *s3, *s4;
  523.  
  524.         j_status (">-> PKT (format='%c'  type='%c'  crc=%d  len=%d)",
  525.             (char) format, (char) type, crc32 ? 32 : 16, (int) len - 1);
  526.  
  527.         switch (type)
  528.         {
  529.         case HPKT_START:
  530.             j_status (">   <autostr>START");
  531.             break;
  532.         case HPKT_INIT:
  533.             s1 = ((char *) txbufin) + ((int) strlen ((char *) txbufin)) + 1;
  534.             s2 = s1 + ((int) strlen (s1)) + 1;
  535.             s3 = s2 + ((int) strlen (s2)) + 1;
  536.             s4 = s3 + ((int) strlen (s3)) + 1;
  537.             /*                          j_status(">   INIT (appinfo='%s'  can='%s'  want='%s'  options='%s'  pktprefix='%s')",
  538.                                        (char *) txbufin, s1, s2, s3, s4); */
  539.             break;
  540.         case HPKT_INITACK:
  541.             j_status (">   INITACK");
  542.             break;
  543.         case HPKT_FINFO:
  544.             j_status (">   FINFO (%s)", txbufin);
  545.             break;
  546.         case HPKT_FINFOACK:
  547.             if (rxfd >= 0)
  548.             {
  549.                 if (rxpos > 0L)
  550.                     s1 = "RES";
  551.                 else
  552.                     s1 = "BOF";
  553.             }
  554.             else if (rxpos == -1L)
  555.                 s1 = "HAVE";
  556.             else if (rxpos == -2L)
  557.                 s1 = "SKIP";
  558.             else
  559.                 s1 = "EOB";
  560.             j_status (">   FINFOACK (pos=%ld %s  rxstate=%d  rxfd=%d)",
  561.                 rxpos, s1, (int) rxstate, rxfd);
  562.             break;
  563.         case HPKT_DATA:
  564.             j_status (">   DATA (ofs=%ld  len=%d)",
  565.                 intell (h_long1 (txbufin)), (int) len - 5);
  566.             break;
  567.         case HPKT_DATAACK:
  568.             j_status (">   DATAACK (ofs=%ld)",
  569.                 intell (h_long1 (txbufin)));
  570.             break;
  571.         case HPKT_RPOS:
  572.             j_status (">   RPOS (pos=%ld%s  blklen=%ld  syncid=%ld)",
  573.                 rxpos, rxpos < 0L ? " SKIP" : "",
  574.                 intell (h_long2 (txbufin)), rxsyncid);
  575.             break;
  576.         case HPKT_EOF:
  577.             j_status (">   EOF (ofs=%ld%s)",
  578.                 txpos, txpos < 0L ? " SKIP" : "");
  579.             break;
  580.         case HPKT_EOFACK:
  581.             j_status (">   EOFACK");
  582.             break;
  583.         case HPKT_IDLE:
  584.             j_status (">   IDLE");
  585.             break;
  586.         case HPKT_END:
  587.             j_status (">   END");
  588.             break;
  589. #ifdef HYDRADEV
  590.         case HPKT_DEVDATA:
  591.             j_status (">   DEVDATA (id=%ld  dev='%s'  len=%hu)",
  592.                 devtxid, devtxdev, devtxlen);
  593.             break;
  594.         case HPKT_DEVDACK:
  595.             j_status (">   DEVDACK (id=%ld)",
  596.                 intell (h_long1 (rxbuf)));
  597.             break;
  598. #endif
  599.         default:                /* This couldn't possibly happen! ;-) */
  600.             break;
  601.         }
  602.     }
  603. #endif
  604.  
  605.     if (crc32)
  606.     {
  607.         ULONG crc = CRC32POST (crc32block (crc32tab, CRC32INIT, txbufin, len));    /*AGL:10mar93*/
  608.  
  609.         txbufin[len++] = (byte) crc;
  610.         txbufin[len++] = (byte) (crc >> 8);
  611.         txbufin[len++] = (byte) (crc >> 16);
  612.         txbufin[len++] = (byte) (crc >> 24);
  613.     }
  614.     else
  615.     {
  616.         word crc = CRC16POST (crc16block (crc16tab, CRC16INIT, txbufin, len));    /*AGL:10mar93*/
  617.  
  618.         txbufin[len++] = (byte) crc;
  619.         txbufin[len++] = (byte) (crc >> 8);
  620.     }
  621.  
  622.     in = txbufin;
  623.     out = txbuf;
  624.     txlastc = 0;
  625.     *out++ = H_DLE;
  626.     *out++ = format;
  627.  
  628.     switch (format)
  629.     {
  630.     case HCHR_HEXPKT:
  631.         for (; len > 0; len--, in++)
  632.         {
  633.             if (*in & 0x80)
  634.             {
  635.                 *out++ = '\\';
  636.                 *out++ = hexdigit[((*in) >> 4) & 0x0f];
  637.                 *out++ = hexdigit[(*in) & 0x0f];
  638.             }
  639.             else if (*in < 32 || *in == 127)
  640.             {
  641.                 *out++ = H_DLE;
  642.                 *out++ = (byte)((*in) ^ 0x40);
  643.             }
  644.             else if (*in == '\\')
  645.             {
  646.                 *out++ = '\\';
  647.                 *out++ = '\\';
  648.             }
  649.             else
  650.                 *out++ = *in;
  651.         }
  652.         break;
  653.  
  654.     case HCHR_BINPKT:
  655.         for (; len > 0; len--)
  656.             out = put_binbyte (out, *in++);
  657.         break;
  658.  
  659.     case HCHR_ASCPKT:
  660.         for (n = c = 0; len > 0; len--)
  661.         {
  662.             c |= ((*in++) << n);
  663.             out = put_binbyte (out, (byte)(c & 0x7f));
  664.             c >>= 7;
  665.             if (++n >= 7)
  666.             {
  667.                 out = put_binbyte (out, (byte)(c & 0x7f));
  668.                 n = c = 0;
  669.             }
  670.         }
  671.         if (n > 0)
  672.             out = put_binbyte (out, (byte)(c & 0x7f));
  673.         break;
  674.  
  675.     case HCHR_UUEPKT:
  676.         for (; len >= 3; in += 3, len -= 3)
  677.         {
  678.             *out++ = (byte) h_uuenc (in[0] >> 2);
  679.             *out++ = (byte) h_uuenc (((in[0] << 4) & 0x30) | ((in[1] >> 4) & 0x0f));
  680.             *out++ = (byte) h_uuenc (((in[1] << 2) & 0x3c) | ((in[2] >> 6) & 0x03));
  681.             *out++ = (byte) h_uuenc (in[2] & 0x3f);
  682.         }
  683.         if (len > 0)
  684.         {
  685.             *out++ = (byte) h_uuenc (in[0] >> 2);
  686.             *out++ = (byte) h_uuenc (((in[0] << 4) & 0x30) | ((in[1] >> 4) & 0x0f));
  687.             if (len == 2)
  688.                 *out++ = (byte) h_uuenc ((in[1] << 2) & 0x3c);
  689.         }
  690.         break;
  691.     }
  692.  
  693.     *out++ = H_DLE;
  694.     *out++ = HCHR_PKTEND;
  695.  
  696.     if (type != HPKT_DATA && format != HCHR_BINPKT)
  697.     {
  698.         *out++ = '\r';
  699.         *out++ = '\n';
  700.     }
  701.  
  702.     for (in = (byte *) txpktprefix; *in; in++)
  703.     {
  704.         switch (*in)
  705.         {
  706.         case 221:                /* transmit break signal for one second */
  707.             do_break(TRUE);
  708.             {
  709.                 h_timer t = h_timer_set (2);
  710.                 while (!h_timer_expired (t, h_timer_get ()))
  711.                     time_release ();
  712.             }
  713.             do_break(FALSE);
  714.             break;
  715.         case 222:
  716.             {
  717.                 h_timer t = h_timer_set (2);
  718.  
  719.                 while (!h_timer_expired (t, h_timer_get ()))
  720.                     time_release ();
  721.             }
  722.             break;
  723.         case 223:
  724.             SENDBYTE (0);
  725.             break;
  726.         default:
  727.             SENDBYTE (*in);
  728.             break;
  729.         }
  730.     }
  731.  
  732.     ComTXBlockTimeout (txbuf, (USHORT) (out - txbuf), braindead);
  733. }                                /*txpkt()*/
  734.  
  735. /*---------------------------------------------------------------------------*/
  736. static int 
  737. rxpkt (void)
  738. {
  739.     register byte *p, *q = rxbuf;
  740.     register word n, i;
  741.     short c;
  742.     h_timer tnow = h_timer_get ();    /*AGL:16jul93*/
  743.  
  744.     if (got_ESC ())
  745.         return (H_SYSABORT);
  746.     if (!CARRIER)
  747.         return (H_CARRIER);
  748.  
  749.     if (h_timer_running (braindead) && h_timer_expired (braindead, tnow))
  750.     {
  751. #ifdef DEBUG
  752.         if (debugging_log)
  753.             j_status (" <- BrainDead (timer=%08lx  time=%08lx)", braindead, tnow);
  754. #endif
  755.         return (H_BRAINTIME);
  756.     }
  757.  
  758.     if (h_timer_running (txtimer) && h_timer_expired (txtimer, tnow))
  759.     {
  760. #ifdef DEBUG
  761.         if (debugging_log)
  762.             j_status (" <- TxTimer (timer=%08lx  time=%08lx)", txtimer, tnow);
  763. #endif
  764.         return (H_TXTIME);
  765.     }
  766.  
  767. #ifdef HYDRADEV
  768.     if (h_timer_running (devtxtimer) && h_timer_expired (devtxtimer, tnow))
  769.     {
  770. #ifdef DEBUG
  771.         if (debugging_log)
  772.             j_status (" <- DevTxTimer (timer=%08lx  time=%08lx)", devtxtimer, time (NULL));
  773. #endif
  774.         return (H_DEVTXTIME);
  775.     }
  776. #endif
  777.  
  778.     p = rxbufptr;
  779.  
  780.     while (CHAR_AVAIL ())
  781.     {
  782.         c = MODEM_IN ();
  783.         if (rxoptions & HOPT_HIGHBIT)
  784.             c &= 0x7f;
  785.  
  786.         n = c;
  787.         if (rxoptions & HOPT_HIGHCTL)
  788.             n &= 0x7f;
  789.         if (n != H_DLE &&
  790.             (((rxoptions & HOPT_XONXOFF) && (n == XON || n == XOFF)) ||
  791.                 ((rxoptions & HOPT_CTLCHRS) && (n < 32 || n == 127))))
  792.             continue;
  793.  
  794.         if (rxdle || c == H_DLE)
  795.         {
  796.             switch (c)
  797.             {
  798.             case H_DLE:
  799.                 if (++rxdle >= 5)
  800.                     return (H_CANCEL);
  801.                 break;
  802.  
  803.             case HCHR_PKTEND:
  804.                 rxbufptr = p;
  805.  
  806.                 switch (rxpktformat)
  807.                 {
  808.                 case HCHR_BINPKT:
  809.                     q = rxbufptr;
  810.                     break;
  811.  
  812.                 case HCHR_HEXPKT:
  813.                     for (p = q = rxbuf; p < rxbufptr; p++)
  814.                     {
  815.                         if (*p == '\\' && *++p != '\\')
  816.                         {
  817.                             i = *p;
  818.                             n = *++p;
  819.                             if ((i -= '0') > 9)
  820.                                 i -= ('a' - ':');
  821.                             if ((n -= '0') > 9)
  822.                                 n -= ('a' - ':');
  823.                             if ((i & ~0x0f) || (n & ~0x0f))
  824.                             {
  825.                                 c = H_NOPKT;
  826.                                 break;
  827.                             }
  828.                             *q++ = (byte) ((i << 4) | n);
  829.                         }
  830.                         else
  831.                             *q++ = *p;
  832.                     }
  833.                     if (p > rxbufptr)
  834.                         c = H_NOPKT;
  835.                     break;
  836.  
  837.                 case HCHR_ASCPKT:
  838.                     n = i = 0;
  839.                     for (p = q = rxbuf; p < rxbufptr; p++)
  840.                     {
  841.                         i |= ((*p & 0x7f) << n);
  842.                         if ((n += 7) >= 8)
  843.                         {
  844.                             *q++ = (byte) (i & 0xff);
  845.                             i >>= 8;
  846.                             n -= 8;
  847.                         }
  848.                     }
  849.                     break;
  850.  
  851.                 case HCHR_UUEPKT:
  852.                     n = (int) (rxbufptr - rxbuf);
  853.                     for (p = q = rxbuf; n >= 4; n -= 4, p += 4)
  854.                     {
  855.                         if (p[0] <= ' ' || p[0] >= 'a' ||
  856.                             p[1] <= ' ' || p[1] >= 'a' ||
  857.                             p[2] <= ' ' || p[2] >= 'a' ||
  858.                             p[3] <= ' ' || p[3] >= 'a')
  859.                         {
  860.                             c = H_NOPKT;
  861.                             break;
  862.                         }
  863.                         *q++ = (byte) ((h_uudec (p[0]) << 2) | (h_uudec (p[1]) >> 4));
  864.                         *q++ = (byte) ((h_uudec (p[1]) << 4) | (h_uudec (p[2]) >> 2));
  865.                         *q++ = (byte) ((h_uudec (p[2]) << 6) | h_uudec (p[3]));
  866.                     }
  867.                     if (n >= 2)
  868.                     {
  869.                         if (p[0] <= ' ' || p[0] >= 'a' ||
  870.                             p[1] <= ' ' || p[1] >= 'a')
  871.                         {
  872.                             c = H_NOPKT;
  873.                             break;
  874.                         }
  875.                         *q++ = (byte) ((h_uudec (p[0]) << 2) | (h_uudec (p[1]) >> 4));
  876.                         if (n == 3)
  877.                         {
  878.                             if (p[2] <= ' ' || p[2] >= 'a')
  879.                             {
  880.                                 c = H_NOPKT;
  881.                                 break;
  882.                             }
  883.                             *q++ = (byte) ((h_uudec (p[1]) << 4) | (h_uudec (p[2]) >> 2));
  884.                         }
  885.                     }
  886.                     break;
  887.  
  888.                 default:        /* This'd mean internal fluke */
  889. #ifdef DEBUG
  890.                     if (debugging_log)
  891.                     {
  892.                         j_status (" <- <PKTEND> (pktformat='%c' dec=%d hex=%02x) ??",
  893.                             (char) rxpktformat, (int) rxpktformat, (int) rxpktformat);
  894.                     }
  895. #endif
  896.                     c = H_NOPKT;
  897.                     break;
  898.                 }
  899.  
  900.                 rxbufptr = NULL;
  901.  
  902.                 if (c == H_NOPKT)
  903.                     break;
  904.  
  905.                 rxpktlen = (word) (q - rxbuf);
  906.                 if (rxpktformat != HCHR_HEXPKT && (rxoptions & HOPT_CRC32))
  907.                 {
  908.                     if (rxpktlen < 5)
  909.                     {
  910.                         c = H_NOPKT;
  911.                         break;
  912.                     }
  913.                     n = h_crc32test (crc32block (crc32tab, CRC32INIT, rxbuf, rxpktlen));    /*AGL:10mar93*/
  914.                     rxpktlen -= (int) sizeof (long);    /* remove CRC-32 */
  915.                 }
  916.                 else
  917.                 {
  918.                     if (rxpktlen < 3)
  919.                     {
  920.                         c = H_NOPKT;
  921.                         break;
  922.                     }
  923.                     n = h_crc16test (crc16block (crc16tab, CRC16INIT, rxbuf, rxpktlen));    /*AGL:10mar93*/
  924.                     rxpktlen -= (int) sizeof (word);    /* remove CRC-16 */
  925.                 }
  926.  
  927.                 rxpktlen--;        /* remove type  */
  928.  
  929.                 if (n)
  930.                 {
  931. #ifdef DEBUG
  932.                     if (debugging_log)
  933.                     {
  934.                         char *s1, *s2, *s3, *s4;
  935.  
  936.                         j_status ("><- PKT (format='%c'  type='%c'  len=%hd)",
  937.                             (char) rxpktformat, rxbuf[rxpktlen], rxpktlen);
  938.  
  939.                         switch (rxbuf[rxpktlen])
  940.                         {
  941.                         case HPKT_START:
  942.                             j_status ("<   START");
  943.                             break;
  944.                         case HPKT_INIT:
  945.                             s1 = ((char *) rxbuf) + ((int) strlen ((char *) rxbuf)) + 1;
  946.                             s2 = s1 + ((int) strlen (s1)) + 1;
  947.                             s3 = s2 + ((int) strlen (s2)) + 1;
  948.                             s4 = s3 + ((int) strlen (s3)) + 1;
  949.                             /*                                          j_status("<   INIT (appinfo='%s'  can='%s'  want='%s'  options='%s'  pktprefix='%s')",
  950.                                                      (char *) rxbuf, s1, s2, s3, s4);  */
  951.                             break;
  952.                         case HPKT_INITACK:
  953.                             j_status ("<   INITACK");
  954.                             break;
  955.                         case HPKT_FINFO:
  956.                             j_status ("<   FINFO ('%s'  rxstate=%d)", rxbuf, (int) rxstate);
  957.                             break;
  958.                         case HPKT_FINFOACK:
  959.                             j_status ("<   FINFOACK (pos=%ld  txstate=%d  txfd=%d)",
  960.                                 intell (h_long1 (rxbuf)), (int) txstate, txfd);
  961.                             break;
  962.                         case HPKT_DATA:
  963.                             j_status ("<   DATA (rxstate=%d  pos=%ld  len=%hu)",
  964.                                 (int) rxstate, intell (h_long1 (rxbuf)),
  965.                                 (word) (rxpktlen - ((int) sizeof (long))));
  966.  
  967.                             break;
  968.                         case HPKT_DATAACK:
  969.                             j_status ("<   DATAACK (rxstate=%d  pos=%ld)",
  970.                                 (int) rxstate, intell (h_long1 (rxbuf)));
  971.                             break;
  972.                         case HPKT_RPOS:
  973.                             j_status ("<   RPOS (pos=%ld%s  blklen=%hu->%ld  syncid=%ld%s  txstate=%d  txfd=%d)",
  974.                                 intell (h_long1 (rxbuf)),
  975.                                 intell (h_long1 (rxbuf)) < 0L ? " SKIP" : "",
  976.                                 txblklen, intell (h_long2 (rxbuf)),
  977.                                 intell (h_long3 (rxbuf)),
  978.                                 intell (h_long3 (rxbuf)) == rxsyncid ? " DUP" : "",
  979.                                 (int) txstate, txfd);
  980.                             break;
  981.                         case HPKT_EOF:
  982.                             j_status ("<   EOF (rxstate=%d  pos=%ld%s)",
  983.                                 (int) rxstate, intell (h_long1 (rxbuf)),
  984.                                 intell (h_long1 (rxbuf)) < 0L ? " SKIP" : "");
  985.                             break;
  986.                         case HPKT_EOFACK:
  987.                             j_status ("<   EOFACK (txstate=%d)", (int) txstate);
  988.                             break;
  989.                         case HPKT_IDLE:
  990.                             j_status ("<   IDLE");
  991.                             break;
  992.                         case HPKT_END:
  993.                             j_status ("<   END");
  994.                             break;
  995. #ifdef HYDRADEV
  996.                         case HPKT_DEVDATA:
  997.                             s1 = ((char *) rxbuf) + ((int) sizeof (long));
  998.  
  999.                             j_status ("<   DEVDATA (id=%ld  dev=%s  len=%u",
  1000.                                 intell (h_long1 (rxbuf)), s1,
  1001.                                 (int) rxpktlen - (((int) sizeof (long)) + ((int) strlen (s1)) + 1));
  1002.  
  1003.                             break;
  1004.                         case HPKT_DEVDACK:
  1005.                             j_status ("<   DEVDACK (devtxstate=%d  id=%ld)",
  1006.                                 (int) devtxstate, intell (h_long1 (rxbuf)));
  1007.                             break;
  1008. #endif
  1009.                         default:
  1010.                             j_status ("<   Unkown pkttype %c (txstate=%d  rxstate=%d)",
  1011.                                 rxbuf[rxpktlen], (int) txstate, (int) rxstate);
  1012.                             break;
  1013.                         }
  1014.                     }
  1015. #endif
  1016.                     return ((int) rxbuf[rxpktlen]);
  1017.                 }                /*goodpkt*/
  1018.  
  1019. #ifdef DEBUG
  1020.                 if (debugging_log)
  1021.                     j_status (">Bad CRC (format='%c'  type='%c'  len=%d)",
  1022.                         (char) rxpktformat, rxbuf[rxpktlen], (int) rxpktlen);
  1023. #endif
  1024.                 break;
  1025.  
  1026.             case HCHR_BINPKT:
  1027.             case HCHR_HEXPKT:
  1028.             case HCHR_ASCPKT:
  1029.             case HCHR_UUEPKT:
  1030. #ifdef DEBUG
  1031.                 if (debugging_log)
  1032.                     j_status (" <- <PKTSTART> (pktformat='%c')", (char) c);
  1033. #endif
  1034.                 rxpktformat = (byte) c;
  1035.                 p = rxbufptr = rxbuf;
  1036.                 rxdle = 0;
  1037.                 break;
  1038.  
  1039.             default:
  1040.                 if (p)
  1041.                 {
  1042.                     if (p < rxbufmax)
  1043.                         *p++ = (byte) (c ^ 0x40);
  1044.                     else
  1045.                     {
  1046. #ifdef DEBUG
  1047.                         if (debugging_log)
  1048.                             j_status (" <- Pkt too long - discarded");
  1049. #endif
  1050.                         p = NULL;
  1051.                     }
  1052.                 }
  1053.                 rxdle = 0;
  1054.                 break;
  1055.             }                    /* case */
  1056.         }
  1057.         else if (p)
  1058.         {
  1059.             if (p < rxbufmax)
  1060.                 *p++ = (byte) c;
  1061.             else
  1062.             {
  1063. #ifdef DEBUG
  1064.                 if (debugging_log)
  1065.                     j_status (" <- Pkt too long - discarded");
  1066. #endif
  1067.                 p = NULL;
  1068.             }
  1069.         }
  1070.     }
  1071.  
  1072.     rxbufptr = p;
  1073.  
  1074.     time_release ();
  1075.     return (H_NOPKT);
  1076. }                                /*rxpkt()*/
  1077.  
  1078. /*---------------------------------------------------------------------------*/
  1079. void 
  1080. hydra_badxfer (void)
  1081. {
  1082.     if (rxfd >= 0)
  1083.     {
  1084.         close (rxfd);
  1085.         rxfd = -1;
  1086.         if (remote_capabilities)
  1087.         {
  1088.             if (!Resume_WaZOO)
  1089.             {
  1090.                 add_abort (Abortlog_name, Resume_name, rxpathname, CURRENT.sc_Inbound, Resume_info);
  1091.             }
  1092.         }
  1093.         else
  1094.         {
  1095.             (void) unlink (rxpathname);
  1096.         }
  1097.     }
  1098. }                                /*hydra_badxfer()*/
  1099.  
  1100. /*---------------------------------------------------------------------------*/
  1101. void 
  1102. hydra_init (ULONG want_options)
  1103. {
  1104.     char *HoldName;
  1105.  
  1106.     txbuf = Txbuf;
  1107.     rxbuf = txbuf + H_BUFLEN;
  1108.  
  1109.     crc16tab = (word *) malloc (CRC_TABSIZE * ((int) sizeof (word)));
  1110.     crc32tab = (ULONG *) malloc (CRC_TABSIZE * ((int) sizeof (ULONG)));
  1111.  
  1112.     if (!txbuf || !rxbuf || !crc16tab || !crc32tab)
  1113.     {
  1114.         status_line (MSG_TXT (M_MEM_ERROR));
  1115.         mdm_hangup ();
  1116.         return;
  1117.     }
  1118.     txbufin = txbuf + ((H_MAXBLKLEN + H_OVERHEAD + 5) * 2);
  1119.     rxbufmax = rxbuf + H_MAXPKTLEN;
  1120.  
  1121.     crc16init (crc16tab, CRC16POLY);
  1122.     crc32init (crc32tab, CRC32POLY);
  1123.  
  1124.     batchesdone = 0;
  1125.     mail_finished = 1;
  1126.  
  1127.     originator = remote_capabilities ? (isOriginator ? TRUE : FALSE) : TRUE;
  1128.  
  1129.     HoldName = HoldAreaNameMunge (&called_addr);
  1130.  
  1131.     (void) sprintf (Abortlog_name, "%s%s.Z\0",
  1132.         HoldName, Hex_Addr_Str (&remote_addr));
  1133.  
  1134.     if (originator)
  1135.         hdxlink = FALSE;
  1136.     else
  1137.         hdxlink = !((janus_baud >= cur_baud.rate_value) || (janus_OK));
  1138.  
  1139.     options = (want_options & HCAN_OPTIONS) & ~HUNN_OPTIONS;
  1140.  
  1141.     timeout = (word) (40960L / cur_baud.rate_value);
  1142.     if (timeout < H_MINTIMER)
  1143.         timeout = H_MINTIMER;
  1144.     else if (timeout > H_MAXTIMER)
  1145.         timeout = H_MAXTIMER;
  1146.  
  1147.     txmaxblklen = (short) ((cur_baud.rate_value / 300) * 128);
  1148.     if (txmaxblklen < 256)
  1149.         txmaxblklen = 256;
  1150.     else if (txmaxblklen > H_MAXBLKLEN)
  1151.         txmaxblklen = H_MAXBLKLEN;
  1152.  
  1153.     rxblklen = txblklen = (cur_baud.rate_value < 2400U) ? 256 : 512;
  1154.  
  1155.     txgoodbytes = 0;
  1156.     txgoodneeded = txmaxblklen;    /*AGL:23feb93*/
  1157.  
  1158.     txstate = HTX_DONE;
  1159.  
  1160.     set_prior (3);                /* Time Critical */
  1161.     XON_DISABLE ();
  1162.  
  1163.     if (un_attended && fullscreen)
  1164.     {
  1165.         clear_filetransfer ();
  1166.         sb_show ();
  1167.         Tx_y = 1;
  1168.         Rx_y = 2;
  1169.     }
  1170.     else
  1171.     {
  1172.         set_xy (NULL);
  1173.         Rx_y = Tx_y = Next_y = locate_y;
  1174.     }
  1175.  
  1176. }                                /*hydra_init()*/
  1177.  
  1178. /*---------------------------------------------------------------------------*/
  1179. void 
  1180. hydra_deinit (void)
  1181. {
  1182.     free (crc16tab);
  1183.     free (crc32tab);
  1184.  
  1185.     set_prior (4);                /* Always High */
  1186. }                                /*hydra_deinit()*/
  1187.  
  1188. /*---------------------------------------------------------------------------*/
  1189. int 
  1190. hydra (char *txpathname, char *txalias)
  1191. {
  1192.     int res = 0;
  1193.     int pkttype;
  1194.     char *p, *q;
  1195.     int i;
  1196.     struct stat f;
  1197.  
  1198.     /*-------------------------------------------------------------------*/
  1199.     if (txstate == HTX_DONE)
  1200.     {
  1201.         txstate = HTX_START;
  1202.         txoptions = HTXI_OPTIONS;
  1203.         txpktprefix[0] = '\0';
  1204.  
  1205.         rxstate = HRX_INIT;
  1206.         rxoptions = HRXI_OPTIONS;
  1207.         rxfd = -1;
  1208.         rxdle = 0;
  1209.         rxbufptr = NULL;
  1210.         rxtimer = h_timer_reset ();
  1211.  
  1212. #ifdef HYDRADEV
  1213.         devtxid = devrxid = 0L;
  1214.         devtxtimer = h_timer_reset ();
  1215.         devtxstate = HTD_DONE;
  1216. #endif
  1217.  
  1218.         braindead = h_timer_set (H_BRAINDEAD);
  1219.     }
  1220.     else
  1221.         txstate = HTX_FINFO;
  1222.  
  1223.     txtimer = h_timer_reset ();
  1224.     txretries = 0;
  1225.  
  1226.     /*-------------------------------------------------------------------*/
  1227.     if (txpathname)
  1228.     {
  1229.         stat (txpathname, &f);
  1230.         txfsize = f.st_size;
  1231.         txftime = f.st_mtime;
  1232.  
  1233.         if ((txfd = share_open (txpathname, O_RDONLY | O_BINARY, DENY_WRITE)) < 0)
  1234.         {
  1235.             j_error (MSG_TXT (M_OPEN_MSG), txpathname);
  1236.             return (XFER_SKIP);
  1237.         }
  1238.  
  1239.         if (isatty (txfd))
  1240.         {
  1241.             errno = 1;
  1242.             (void) j_error (MSG_TXT (M_DEVICE_MSG), txpathname);
  1243.             close (txfd);
  1244.             return (XFER_SKIP);
  1245.         }
  1246.  
  1247.         strupr (txpathname);
  1248.         for (p = txpathname, q = txfname; *p; p++)
  1249.         {
  1250.             if (*q = *p, *p == '\\' || *p == ':' || *p == '/')
  1251.                 q = txfname;
  1252.             else
  1253.                 q++;
  1254.         }
  1255.         *q = '\0';
  1256.  
  1257.         if (txalias)
  1258.             strupr (txalias);
  1259.  
  1260.         txstart = 0L;
  1261.         txsyncid = 0L;
  1262.     }
  1263.     else
  1264.     {
  1265.         txfd = -1;
  1266.         strcpy (txfname, "");
  1267.     }
  1268.  
  1269.     /*-------------------------------------------------------------------*/
  1270.     do
  1271.     {
  1272. #ifdef HYDRADEV
  1273.         /*----------------------------------------------------------------*/
  1274.         switch (devtxstate)
  1275.         {
  1276.             /*---------------------------------------------------------*/
  1277.         case HTD_DATA:
  1278.             if (txstate > HTX_RINIT)
  1279.             {
  1280.                 h_long1 (txbufin) = intell (devtxid);
  1281.                 p = ((char *) txbufin) + ((int) sizeof (long));
  1282.  
  1283.                 strcpy (p, devtxdev);
  1284.                 p += H_FLAGLEN + 1;
  1285.                 memcpy (p, devtxbuf, devtxlen);
  1286.                 txpkt (((int) sizeof (long)) + H_FLAGLEN + 1 + devtxlen, HPKT_DEVDATA);
  1287.  
  1288.                 devtxtimer = h_timer_set ((!rxstate && txstate == HTX_REND) ? timeout / 2 : timeout);    /*AGL:10mar93*/
  1289.                 devtxstate = HTD_DACK;
  1290.             }
  1291.             break;
  1292.  
  1293.             /*---------------------------------------------------------*/
  1294.         default:
  1295.             break;
  1296.  
  1297.             /*---------------------------------------------------------*/
  1298.         }
  1299. #endif
  1300.         /*----------------------------------------------------------------*/
  1301.         switch (txstate)
  1302.         {
  1303.             /*---------------------------------------------------------*/
  1304.         case HTX_START:
  1305.             SENDCHARS (autostr, (int) strlen (autostr), 1);
  1306.             txpkt (0, HPKT_START);
  1307.             txtimer = h_timer_set (H_START);
  1308.             txstate = HTX_SWAIT;
  1309.             break;
  1310.  
  1311.             /*---------------------------------------------------------*/
  1312.         case HTX_INIT:
  1313.             p = (char *) txbufin;
  1314.             sprintf (p, "%08lx%s,%s", H_REVSTAMP, PRDCT_PRTY, PRDCT_VRSN);
  1315.             p += ((int) strlen (p)) + 1;    /* our app info & HYDRA rev. */
  1316.             put_flags (p, h_flags, HCAN_OPTIONS);    /* what we CAN  */
  1317.             p += ((int) strlen (p)) + 1;
  1318.             put_flags (p, h_flags, options);    /* what we WANT */
  1319.             p += ((int) strlen (p)) + 1;
  1320.             sprintf (p, "%08lx%08lx",    /* TxRx windows */
  1321.                 hydra_txwindow, hydra_rxwindow);
  1322.             p += ((int) strlen (p)) + 1;
  1323.             strcpy (p, pktprefix);    /* pkt prefix string we want */
  1324.             p += ((int) strlen (p)) + 1;
  1325.  
  1326.             txoptions = HTXI_OPTIONS;
  1327.             txpkt ((word) (((byte *) p) - txbufin), HPKT_INIT);
  1328.             txoptions = rxoptions;
  1329.             txtimer = h_timer_set (timeout / 2);
  1330.             txstate = HTX_INITACK;
  1331.             break;
  1332.  
  1333.             /*---------------------------------------------------------*/
  1334.         case HTX_FINFO:
  1335.             if (txfd >= 0)
  1336.             {
  1337.                 if (!txretries)
  1338.                 {
  1339.                     txoldpos = txoldeta = -1;
  1340.                     if (!un_attended || !fullscreen)
  1341.                         Tx_y = Next_y;
  1342.                     if (txalias)
  1343.                         xfer_summary (MSG_TXT (M_SEND), txalias, &txfsize, Tx_y);
  1344.                     else
  1345.                         xfer_summary (MSG_TXT (M_SEND), txfname, &txfsize, Tx_y);
  1346.                     strlwr (txfname);
  1347.                 }
  1348.                 sprintf ((char *) txbufin, "%08lx%08lx%08lx%08lx%08lx%s",
  1349.                     txftime, txfsize, 0L, 0L, 0L,
  1350.                     txalias ? txalias : txfname);
  1351.             }
  1352.             else
  1353.             {
  1354.                 if (!txretries)
  1355.                 {
  1356.                     j_msgend (Tx_y);
  1357. #ifdef DEBUG
  1358.                     j_status ("+HSEND: End of batch");
  1359. #endif
  1360.                 }
  1361.                 strcpy ((char *) txbufin, txfname);
  1362.             }
  1363.             txpkt (((int) strlen ((char *) txbufin)) + 1, HPKT_FINFO);
  1364.             txtimer = h_timer_set (txretries ? timeout / 2 : timeout);
  1365.             txstate = HTX_FINFOACK;
  1366.             break;
  1367.  
  1368.             /*---------------------------------------------------------*/
  1369.         case HTX_XDATA:
  1370.             if (ComTXRemain () > txmaxblklen)
  1371.                 break;
  1372.  
  1373.             if (txpos < 0L)
  1374.                 i = -1;            /* Skip */
  1375.             else
  1376.             {
  1377.                 h_long1 (txbufin) = intell (txpos);
  1378.                 if ((i = read (txfd, txbufin + ((int) sizeof (long)), txblklen)) < 0)
  1379.                 {
  1380.                     j_error (MSG_TXT (M_READ_MSG), txfname);
  1381.                     close (txfd);
  1382.                     txfd = -1;
  1383.                     txpos = -2L;/* Skip */
  1384.                 }
  1385.             }
  1386.  
  1387.             if (i > 0)
  1388.             {
  1389.                 txpos += i;
  1390.                 txpkt (((int) sizeof (long)) + i, HPKT_DATA);
  1391.  
  1392.                 if (txblklen < txmaxblklen &&
  1393.                     (txgoodbytes += i) >= txgoodneeded)
  1394.                 {
  1395.                     txblklen <<= 1;
  1396.                     if (txblklen >= txmaxblklen)
  1397.                     {
  1398.                         txblklen = txmaxblklen;
  1399.                         txgoodneeded = 0;
  1400.                     }
  1401.                     txgoodbytes = 0;
  1402.                 }
  1403.  
  1404.                 if (txwindow && (txpos >= (txlastack + txwindow)))
  1405.                 {
  1406.                     txtimer = h_timer_set (txretries ? timeout / 2 : timeout);
  1407.                     txstate = HTX_DATAACK;
  1408.                 }
  1409.  
  1410.                 if (!txstart)
  1411.                     txstart = time (NULL);
  1412.                 update_status (&txpos, &txoldpos, txfsize - txpos, &txoldeta, Tx_y);
  1413.                 break;
  1414.             }
  1415.  
  1416.             /* fallthrough to HTX_EOF */
  1417.  
  1418.             /*---------------------------------------------------------*/
  1419.         case HTX_EOF:
  1420.             h_long1 (txbufin) = intell (txpos);
  1421.             txpkt ((int) sizeof (long), HPKT_EOF);
  1422.  
  1423.             txtimer = h_timer_set (txretries ? timeout / 2 : timeout);
  1424.             txstate = HTX_EOFACK;
  1425.             break;
  1426.  
  1427.             /*---------------------------------------------------------*/
  1428.         case HTX_END:
  1429.             txpkt (0, HPKT_END);
  1430.             txpkt (0, HPKT_END);
  1431.             txtimer = h_timer_set (timeout / 2);
  1432.             txstate = HTX_ENDACK;
  1433.             break;
  1434.  
  1435.             /*---------------------------------------------------------*/
  1436.         default:
  1437.             break;
  1438.  
  1439.             /*---------------------------------------------------------*/
  1440.         }
  1441.  
  1442.         /*----------------------------------------------------------------*/
  1443.         pkttype = rxpkt ();
  1444.  
  1445.         /*----------------------------------------------------------*/
  1446.         switch (pkttype)
  1447.         {
  1448.             /*---------------------------------------------------*/
  1449.         case H_CARRIER:
  1450.         case H_CANCEL:
  1451.         case H_SYSABORT:
  1452.         case H_BRAINTIME:
  1453.             switch (pkttype)
  1454.             {
  1455.             case H_CARRIER:
  1456.                 j_status (GenericError, &(MSG_TXT (M_NO_CARRIER)[1]));
  1457.                 break;
  1458.             case H_CANCEL:
  1459.                 j_status (MSG_TXT (M_SESSION_ABORT));
  1460.                 break;
  1461.             case H_SYSABORT:
  1462.                 j_status (GenericError, &(MSG_TXT (M_KBD_MSG)[1]));
  1463.                 break;
  1464.             case H_BRAINTIME:
  1465.                 j_status (MSG_TXT (M_OTHER_DIED));
  1466.                 break;
  1467.             }
  1468.             txstate = HTX_DONE;
  1469.             res = XFER_ABORT;
  1470.             break;
  1471.  
  1472.             /*---------------------------------------------------*/
  1473.         case H_TXTIME:
  1474.             if (txstate == HTX_XWAIT || txstate == HTX_REND)
  1475.             {
  1476.                 txpkt (0, HPKT_IDLE);
  1477.                 txtimer = h_timer_set (H_IDLE);
  1478.                 break;
  1479.             }
  1480.  
  1481.             if (++txretries > H_RETRIES)
  1482.             {
  1483.                 j_status (MSG_TXT (M_FUBAR_MSG));
  1484.                 txstate = HTX_DONE;
  1485.                 res = XFER_ABORT;
  1486.                 break;
  1487.             }
  1488.  
  1489.             j_message (Tx_y, MSG_TXT (M_TIMEOUT));
  1490. #ifdef DEBUG
  1491.             j_status ("-HSEND: Timeout - Retry %u", txretries);
  1492. #endif
  1493.             txtimer = h_timer_reset ();
  1494.  
  1495.             switch (txstate)
  1496.             {
  1497.             case HTX_SWAIT:
  1498.                 txstate = HTX_START;
  1499.                 break;
  1500.             case HTX_INITACK:
  1501.                 txstate = HTX_INIT;
  1502.                 break;
  1503.             case HTX_FINFOACK:
  1504.                 txstate = HTX_FINFO;
  1505.                 break;
  1506.             case HTX_DATAACK:
  1507.                 txstate = HTX_XDATA;
  1508.                 break;
  1509.             case HTX_EOFACK:
  1510.                 txstate = HTX_EOF;
  1511.                 break;
  1512.             case HTX_ENDACK:
  1513.                 txstate = HTX_END;
  1514.                 break;
  1515.             }
  1516.             break;
  1517.  
  1518.             /*---------------------------------------------------*/
  1519. #ifdef HYDRADEV
  1520.         case H_DEVTXTIME:
  1521.             if (++devtxretries > H_RETRIES)
  1522.             {
  1523.                 j_status (MSG_TXT (M_FUBAR_MSG));
  1524.                 txstate = HTX_DONE;
  1525.                 res = XFER_ABORT;
  1526.                 break;
  1527.             }
  1528.  
  1529.             j_message (Tx_y, MSG_TXT (M_TIMEOUT));
  1530. #ifdef DEBUG
  1531.             j_status ("-HDEVTX: Timeout - Retry %u", devtxretries);
  1532. #endif
  1533.             devtxtimer = h_timer_reset ();
  1534.             devtxstate = HTD_DATA;
  1535.             break;
  1536. #endif
  1537.             /*---------------------------------------------------*/
  1538.         case HPKT_START:
  1539.             if (txstate == HTX_START || txstate == HTX_SWAIT)
  1540.             {
  1541.                 txtimer = h_timer_reset ();
  1542.                 txretries = 0;
  1543.                 txstate = HTX_INIT;
  1544.                 braindead = h_timer_set (H_BRAINDEAD);
  1545.             }
  1546.             break;
  1547.  
  1548.             /*---------------------------------------------------*/
  1549.         case HPKT_INIT:
  1550.             if (rxstate == HRX_INIT)
  1551.             {
  1552.                 p = (char *) rxbuf;
  1553.                 p += ((int) strlen (p)) + 1;
  1554.                 q = p + ((int) strlen (p)) + 1;
  1555.                 rxoptions = options | HUNN_OPTIONS;
  1556.                 rxoptions |= get_flags (q, h_flags);
  1557.                 rxoptions &= get_flags (p, h_flags);
  1558.                 rxoptions &= HCAN_OPTIONS;
  1559.                 if (rxoptions < (options & HNEC_OPTIONS))
  1560.                 {
  1561.                     j_status ("!HYDRA: Incompatible on this link");
  1562.                     txstate = HTX_DONE;
  1563.                     res = XFER_ABORT;
  1564.                     break;
  1565.                 }
  1566.                 p = q + ((int) strlen (q)) + 1;
  1567.                 rxwindow = txwindow = 0L;
  1568.                 sscanf (p, "%08lx%08lx", &rxwindow, &txwindow);
  1569.                 if (rxwindow < 0L)
  1570.                     rxwindow = 0L;
  1571.                 if (hydra_rxwindow &&
  1572.                     (!rxwindow || hydra_rxwindow < rxwindow))
  1573.                     rxwindow = hydra_rxwindow;
  1574.                 if (txwindow < 0L)
  1575.                     txwindow = 0L;
  1576.                 if (hydra_txwindow &&
  1577.                     (!txwindow || hydra_txwindow < txwindow))
  1578.                     txwindow = hydra_txwindow;
  1579.                 p += ((int) strlen (p)) + 1;
  1580.                 strncpy (txpktprefix, p, H_PKTPREFIX);
  1581.                 txpktprefix[H_PKTPREFIX] = '\0';
  1582.  
  1583.                 if (!batchesdone)
  1584.                 {
  1585.                     long revstamp;
  1586.  
  1587.                     p = (char *) rxbuf;
  1588.                     sscanf (p, "%08lx", &revstamp);
  1589.                     j_status (">HYDRA: Other's HydraRev=%s",
  1590.                         h_revdate (revstamp));
  1591.                     p += 8;
  1592.                     if ((q = strchr (p, ',')) != NULL)
  1593.                         *q = ' ';
  1594.                     if ((q = strchr (p, ',')) != NULL)
  1595.                         *q = '/';
  1596.                     j_status (">HYDRA: Other's App.Info '%s'", p);
  1597.                     put_flags ((char *) rxbuf, h_flags, rxoptions);
  1598.                     j_status (">HYDRA: Using link options '%s'", rxbuf);
  1599.                     if (txwindow || rxwindow)
  1600.                         j_status (">HYDRA: Window tx=%ld rx=%ld", txwindow, rxwindow);
  1601.                 }
  1602.  
  1603.                 txoptions = rxoptions;
  1604.                 rxstate = HRX_FINFO;
  1605.  
  1606. #ifdef HYDRADEV
  1607.                 if (rxoptions & HOPT_DEVICE)
  1608.                 {
  1609.                     p = "Remote has no chat facility available\r\n";
  1610.                     hydra_devsend ("CON", (byte *) p, (int) strlen (p));
  1611.                 }
  1612. #endif
  1613.             }
  1614.  
  1615.             txpkt (0, HPKT_INITACK);
  1616.             break;
  1617.  
  1618.             /*---------------------------------------------------*/
  1619.         case HPKT_INITACK:
  1620.             if (txstate == HTX_INIT || txstate == HTX_INITACK)
  1621.             {
  1622.                 braindead = h_timer_set (H_BRAINDEAD);
  1623.                 txtimer = h_timer_reset ();
  1624.                 txretries = 0;
  1625.                 txstate = HTX_RINIT;
  1626.             }
  1627.             break;
  1628.  
  1629.             /*---------------------------------------------------*/
  1630.         case HPKT_FINFO:
  1631.             if (rxstate == HRX_FINFO)
  1632.             {
  1633.                 braindead = h_timer_set (H_BRAINDEAD);
  1634.                 if (!rxbuf[0])
  1635.                 {
  1636.                     j_msgend (Rx_y);
  1637. #ifdef DEBUG
  1638.                     j_status ("*HRECV: End of batch");
  1639. #endif
  1640.                     rxpos = 0L;
  1641.                     rxstate = HRX_DONE;
  1642.                     batchesdone++;
  1643.                 }
  1644.                 else
  1645.                 {
  1646.                     long diskfree;
  1647.  
  1648.                     rxfsize = rxftime = 0L;
  1649.                     rxoldpos = rxoldeta = -1;
  1650.                     rxfname[0] = '\0';
  1651.                     sscanf ((char *) rxbuf, "%08lx%08lx%*08lx%*08lx%*08lx%s",
  1652.                         &rxftime, &rxfsize, rxfname);
  1653.                     strlwr (rxfname);
  1654.  
  1655.                     i = strlen (rxfname) - 1;
  1656.                     if ((i > 2) && (rxfname[i - 2] == 'r') &&
  1657.                         (rxfname[i - 1] == 'e') && (rxfname[i] == 'q'))
  1658.                     {
  1659.                         (void) sprintf (&rxfname[i - 1], "%02x", TaskNumber);
  1660.                     }
  1661.  
  1662.                     if (!xfer_init (rxfname, rxfsize, rxftime))    /* Already have file */
  1663.                     {
  1664.                         j_status (MSG_TXT (M_ALREADY_HAVE), rxpathname);
  1665.                         rxpos = -1L;
  1666.                     }
  1667.                     else
  1668.                     {
  1669.                         diskfree = zfree (rxpathname);
  1670.                         if (rxfsize + 10240L > diskfree)
  1671.                         {
  1672.                             j_status (MSG_TXT (M_OUT_OF_DISK_SPACE));
  1673.                             rxpos = -2L;
  1674.                         }
  1675.                         else
  1676.                         {
  1677.                             if (dexists (rxpathname))    /* Resuming? */
  1678.                             {
  1679.                                 if ((rxfd = open (rxpathname, O_RDWR | O_BINARY, 0)) < 0)
  1680.                                 {
  1681.                                     j_error (MSG_TXT (M_OPEN_MSG), rxpathname);
  1682.                                     rxpos = -2L;
  1683.                                 }
  1684.                             }
  1685.                             else if ((rxfd = open (rxpathname, O_CREAT | O_RDWR | O_BINARY, S_IREAD | S_IWRITE)) < 0)
  1686.                             {
  1687.                                 j_error (MSG_TXT (M_OPEN_MSG), rxpathname);
  1688.                                 rxpos = -2L;
  1689.                             }
  1690.  
  1691.                             if (rxfd >= 0)
  1692.                             {
  1693.                                 p = check_netfile (rxfname);
  1694.                                 j_status ("#%s %s %s", MSG_TXT (M_RECEIVING), (p) ? p : " ", rxfname);
  1695.                                 if (!un_attended || !fullscreen)
  1696.                                     Rx_y = Next_y;
  1697.                                 xfer_summary (MSG_TXT (M_RECV), rxfname, &rxfsize, Rx_y);
  1698.                                 if (lseek (rxfd, 0L, SEEK_END) < 0L)
  1699.                                 {
  1700.                                     (void) j_error (MSG_TXT (M_SEEK_MSG), rxpathname);
  1701.                                     hydra_badxfer ();
  1702.                                     rxpos = -2L;
  1703.                                 }
  1704.                                 else
  1705.                                 {
  1706.                                     diskfree = zfree (rxpathname);    /*AGL:07jul93*/
  1707.                                     rxoffset = rxpos = tell (rxfd);
  1708.                                     if (rxpos < 0L)
  1709.                                     {
  1710.                                         (void) j_error (MSG_TXT (M_SEEK_MSG), rxfname);
  1711.                                         hydra_badxfer ();
  1712.                                         rxpos = -2L;
  1713.                                     }
  1714.                                     else
  1715.                                     {
  1716.                                         if ((rxfsize - rxoffset) + 10240L > diskfree)
  1717.                                         {    /*AGL:07jul93*/
  1718.                                             j_status (MSG_TXT (M_OUT_OF_DISK_SPACE));
  1719.                                             hydra_badxfer ();
  1720.                                             rxpos = -2L;
  1721.                                         }
  1722.                                         else
  1723.                                         {
  1724.                                             rxstart = 0L;
  1725.                                             rxtimer = h_timer_reset ();
  1726.                                             rxretries = 0;
  1727.                                             rxlastsync = 0L;
  1728.                                             rxsyncid = 0L;
  1729.                                             update_status (&rxpos, &rxoldpos, rxfsize - rxpos, &rxoldeta, Rx_y);
  1730.                                             if (rxpos > 0L)
  1731.                                             {
  1732.                                                 j_status (MSG_TXT (M_SYNCHRONIZING_OFFSET), rxpos);
  1733.                                             }
  1734.                                             rxstate = HRX_DATA;
  1735.                                         }
  1736.                                     }
  1737.                                 }
  1738.                             }
  1739.                         }
  1740.                     }
  1741.                 }
  1742.             }
  1743.             else if (rxstate == HRX_DONE)
  1744.                 rxpos = (!rxbuf[0]) ? 0L : -2L;
  1745.  
  1746.             h_long1 (txbufin) = intell (rxpos);
  1747.             txpkt ((int) sizeof (long), HPKT_FINFOACK);
  1748.  
  1749.             break;
  1750.  
  1751.             /*---------------------------------------------------*/
  1752.         case HPKT_FINFOACK:
  1753.             if (txstate == HTX_FINFO || txstate == HTX_FINFOACK)
  1754.             {
  1755.                 braindead = h_timer_set (H_BRAINDEAD);
  1756.                 txretries = 0;
  1757.                 if (!txfname[0])
  1758.                 {
  1759.                     txtimer = h_timer_set (H_IDLE);
  1760.                     txstate = HTX_REND;
  1761.                 }
  1762.                 else
  1763.                 {
  1764.                     txtimer = h_timer_reset ();
  1765.                     txpos = intell (h_long1 (rxbuf));
  1766.                     if (txpos >= 0L)
  1767.                     {
  1768.                         txoffset = txpos;
  1769.                         txlastack = txpos;
  1770.                         update_status (&txpos, &txoldpos, txfsize - txpos, &txoldeta, Tx_y);
  1771.                         if (txpos > 0L)
  1772.                         {
  1773.                             j_status (MSG_TXT (M_SYNCHRONIZING_OFFSET), txpos);
  1774.                             if (lseek (txfd, txpos, SEEK_SET) < 0L)
  1775.                             {
  1776.                                 (void) j_error (MSG_TXT (M_SEEK_MSG), txfname);
  1777.                                 close (txfd);
  1778.                                 txfd = -1;
  1779.                                 txpos = -2L;
  1780.                                 txstate = HTX_EOF;
  1781.                                 break;
  1782.                             }
  1783.                         }
  1784.                         txstate = HTX_XDATA;
  1785.                     }
  1786.                     else
  1787.                     {
  1788.                         close (txfd);
  1789.                         if (txpos == -1L)
  1790.                         {
  1791.                             j_status (MSG_TXT (M_REMOTE_REFUSED), txfname);
  1792.                             return (XFER_OK);
  1793.                         }
  1794.                         else
  1795.                             /* (txpos < -1L) file NOT sent */
  1796.                         {
  1797.                             j_status ("+HSEND: Skipping %s", txfname);
  1798.                             return (XFER_SKIP);
  1799.                         }
  1800.                     }
  1801.                 }
  1802.             }
  1803.             break;
  1804.  
  1805.             /*---------------------------------------------------*/
  1806.         case HPKT_DATA:
  1807.             if (rxstate == HRX_DATA)
  1808.             {
  1809.                 if (intell (h_long1 (rxbuf)) != rxpos ||
  1810.                     intell (h_long1 (rxbuf)) < 0L)
  1811.                 {
  1812.                     if (intell (h_long1 (rxbuf)) <= rxlastsync)
  1813.                     {
  1814.                         rxtimer = h_timer_reset ();
  1815.                         rxretries = 0;
  1816.                     }
  1817.                     rxlastsync = intell (h_long1 (rxbuf));
  1818.  
  1819.                     if (!h_timer_running (rxtimer) ||
  1820.                         h_timer_expired (rxtimer, h_timer_get ()))
  1821.                     {
  1822.                         if (rxretries > 4)
  1823.                         {
  1824.                             if (txstate < HTX_REND &&
  1825.                                 !originator && !hdxlink)
  1826.                             {
  1827.                                 hdxlink = TRUE;
  1828.                                 rxretries = 0;
  1829.                             }
  1830.                         }
  1831.                         if (++rxretries > H_RETRIES)
  1832.                         {
  1833.                             j_status (MSG_TXT (M_FUBAR_MSG));
  1834.                             txstate = HTX_DONE;
  1835.                             res = XFER_ABORT;
  1836.                             break;
  1837.                         }
  1838.                         if (rxretries == 1 || rxretries == 4)    /*AGL:14may93*/
  1839.                             rxsyncid++;
  1840.  
  1841.                         rxblklen /= 2;
  1842.                         i = rxblklen;
  1843.                         if (i <= 64)
  1844.                             i = 64;
  1845.                         else if (i <= 128)
  1846.                             i = 128;
  1847.                         else if (i <= 256)
  1848.                             i = 256;
  1849.                         else if (i <= 512)
  1850.                             i = 512;
  1851.                         else
  1852.                             i = 1024;
  1853.                         j_message (Rx_y, MSG_TXT (M_J_BAD_PACKET), rxpos);
  1854. #ifdef DEBUG
  1855.                         j_status ("-HRECV: Bad pkt at %ld - Retry %u (newblklen=%u)",
  1856.                                 rxpos, rxretries, i);
  1857. #endif
  1858.                         h_long1 (txbufin) = intell (rxpos);
  1859.                         h_long2 (txbufin) = intell ((long) i);
  1860.                         h_long3 (txbufin) = intell (rxsyncid);
  1861.                         txpkt (3 * ((int) sizeof (long)), HPKT_RPOS);
  1862.  
  1863.                         rxtimer = h_timer_set (timeout);
  1864.                     }
  1865.                 }
  1866.                 else
  1867.                 {
  1868.                     braindead = h_timer_set (H_BRAINDEAD);
  1869.                     rxpktlen -= (int) sizeof (long);
  1870.  
  1871.                     rxblklen = rxpktlen;
  1872.                     if (write (rxfd, rxbuf + ((int) sizeof (long)), rxpktlen) < 0)
  1873.                     {
  1874.                         j_error (MSG_TXT (M_WRITE_MSG), rxfname);
  1875.                         hydra_badxfer ();
  1876.                         rxpos = -2L;
  1877.                         rxretries = 1;
  1878.                         rxsyncid++;
  1879.                         h_long1 (txbufin) = intell (rxpos);
  1880.                         h_long2 (txbufin) = intell (0L);
  1881.                         h_long3 (txbufin) = intell (rxsyncid);
  1882.                         txpkt (3 * ((int) sizeof (long)), HPKT_RPOS);
  1883.  
  1884.                         rxtimer = h_timer_set (timeout);
  1885.                         break;
  1886.                     }
  1887.                     rxretries = 0;
  1888.                     rxtimer = h_timer_reset ();
  1889.                     rxlastsync = rxpos;
  1890.                     rxpos += rxpktlen;
  1891.                     if (rxwindow)
  1892.                     {
  1893.                         h_long1 (txbufin) = intell (rxpos);
  1894.                         txpkt ((int) sizeof (long), HPKT_DATAACK);
  1895.                     }
  1896.                     if (!rxstart)
  1897.                         rxstart = time (NULL) -
  1898.                             ((rxpktlen * 10) / cur_baud.rate_value);
  1899.                     update_status (&rxpos, &rxoldpos, rxfsize - rxpos, &rxoldeta, Rx_y);
  1900.                 }                /*badpkt*/
  1901.             }                    /*rxstate==HRX_DATA*/
  1902.             break;
  1903.  
  1904.             /*---------------------------------------------------*/
  1905.         case HPKT_DATAACK:
  1906.             if (txstate == HTX_XDATA || txstate == HTX_DATAACK ||
  1907.                 txstate == HTX_XWAIT ||
  1908.                 txstate == HTX_EOF || txstate == HTX_EOFACK)
  1909.             {
  1910.                 if (txwindow && intell (h_long1 (rxbuf)) > txlastack)
  1911.                 {
  1912.                     txlastack = intell (h_long1 (rxbuf));
  1913.                     if (txstate == HTX_DATAACK &&
  1914.                         (txpos < (txlastack + txwindow)))
  1915.                     {
  1916.                         txstate = HTX_XDATA;
  1917.                         txretries = 0;
  1918.                         txtimer = h_timer_reset ();
  1919.                     }
  1920.                 }
  1921.             }
  1922.             break;
  1923.  
  1924.             /*---------------------------------------------------*/
  1925.         case HPKT_RPOS:
  1926.             if (txstate == HTX_XDATA || txstate == HTX_DATAACK ||
  1927.                 txstate == HTX_XWAIT ||
  1928.                 txstate == HTX_EOF || txstate == HTX_EOFACK)
  1929.             {
  1930.                 if (intell (h_long3 (rxbuf)) != txsyncid)
  1931.                 {
  1932.                     txsyncid = intell (h_long3 (rxbuf));
  1933.                     txretries = 1;
  1934.                 }
  1935.                 else
  1936.                     /*AGL:14may93*/
  1937.                 {
  1938.                     if (++txretries > H_RETRIES)
  1939.                     {
  1940.                         j_status (MSG_TXT (M_FUBAR_MSG));
  1941.                         txstate = HTX_DONE;
  1942.                         res = XFER_ABORT;
  1943.                         break;
  1944.                     }
  1945.                     if (txretries != 4)
  1946.                         break;    /*AGL:14may93*/
  1947.                 }
  1948.  
  1949.                 txtimer = h_timer_reset ();
  1950.                 txpos = intell (h_long1 (rxbuf));
  1951.                 if (txpos < 0L)
  1952.                 {
  1953.                     if (txfd >= 0)
  1954.                     {
  1955.                         j_status ("+HSEND: Skipping %s", txfname);
  1956.                         close (txfd);
  1957.                         txfd = -1;
  1958.                         txstate = HTX_EOF;
  1959.                     }
  1960.                     txpos = -2L;
  1961.                     break;
  1962.                 }
  1963.  
  1964.                 if (txblklen > (word) intell (h_long2 (rxbuf)))
  1965.                     txblklen = (word) intell (h_long2 (rxbuf));
  1966.                 else
  1967.                     txblklen >>= 1;
  1968.                 if (txblklen <= 64)
  1969.                     txblklen = 64;
  1970.                 else if (txblklen <= 128)
  1971.                     txblklen = 128;
  1972.                 else if (txblklen <= 256)
  1973.                     txblklen = 256;
  1974.                 else if (txblklen <= 512)
  1975.                     txblklen = 512;
  1976.                 else
  1977.                     txblklen = 1024;
  1978.                 txgoodbytes = 0;
  1979.                 txgoodneeded += txmaxblklen * 2;    /*AGL:23feb93*/
  1980.                 if (txgoodneeded > txmaxblklen * 8)    /*AGL:23feb93*/
  1981.                     txgoodneeded = txmaxblklen * 8;    /*AGL:23feb93*/
  1982.  
  1983.                 update_status (&txpos, &txoldpos, txfsize - txpos, &txoldeta, Tx_y);
  1984.                 j_status (MSG_TXT (M_SYNCHRONIZING_OFFSET), txpos);
  1985.                 if (lseek (txfd, txpos, SEEK_SET) < 0L)
  1986.                 {
  1987.                     (void) j_error (MSG_TXT (M_SEEK_MSG), txfname);
  1988.                     close (txfd);
  1989.                     txfd = -1;
  1990.                     txpos = -2L;
  1991.                     txstate = HTX_EOF;
  1992.                     break;
  1993.                 }
  1994.  
  1995.                 if (txstate != HTX_XWAIT)
  1996.                     txstate = HTX_XDATA;
  1997.             }
  1998.             break;
  1999.  
  2000.             /*---------------------------------------------------*/
  2001.         case HPKT_EOF:
  2002.             if (rxstate == HRX_DATA)
  2003.             {
  2004.                 if (intell (h_long1 (rxbuf)) < 0L)
  2005.                 {
  2006.                     hydra_badxfer ();
  2007.                     j_status ("+HRECV: Skipping %s", rxfname);
  2008.                     rxstate = HRX_FINFO;
  2009.                     braindead = h_timer_set (H_BRAINDEAD);
  2010.                 }
  2011.                 else if (intell (h_long1 (rxbuf)) != rxpos)
  2012.                 {
  2013.                     if (intell (h_long1 (rxbuf)) <= rxlastsync)
  2014.                     {
  2015.                         rxtimer = h_timer_reset ();
  2016.                         rxretries = 0;
  2017.                     }
  2018.                     rxlastsync = intell (h_long1 (rxbuf));
  2019.  
  2020.                     if (!h_timer_running (rxtimer) ||
  2021.                         h_timer_expired (rxtimer, h_timer_get ()))
  2022.                     {
  2023.                         if (++rxretries > H_RETRIES)
  2024.                         {
  2025.                             j_status (MSG_TXT (M_FUBAR_MSG));
  2026.                             txstate = HTX_DONE;
  2027.                             res = XFER_ABORT;
  2028.                             break;
  2029.                         }
  2030.                         if (rxretries == 1 || rxretries == 4)    /*AGL:14may93*/
  2031.                             rxsyncid++;
  2032.  
  2033.                         rxblklen /= 2;
  2034.                         i = rxblklen;
  2035.                         if (i <= 64)
  2036.                             i = 64;
  2037.                         else if (i <= 128)
  2038.                             i = 128;
  2039.                         else if (i <= 256)
  2040.                             i = 256;
  2041.                         else if (i <= 512)
  2042.                             i = 512;
  2043.                         else
  2044.                             i = 1024;
  2045.  
  2046.                         j_status ("-HRECV: Bad EOF at %ld - Retry %u (newblklen=%u)",
  2047.                             rxpos, rxretries, i);
  2048.                         h_long1 (txbufin) = intell (rxpos);
  2049.                         h_long2 (txbufin) = intell ((long) i);
  2050.                         h_long3 (txbufin) = intell (rxsyncid);
  2051.                         txpkt (3 * ((int) sizeof (long)), HPKT_RPOS);
  2052.  
  2053.                         rxtimer = h_timer_set (timeout);
  2054.                     }
  2055.                 }
  2056.                 else
  2057.                 {
  2058.                     long rxtime;
  2059.  
  2060.                     close (rxfd);
  2061.                     rxfd = -1;
  2062.  
  2063.                     if (Resume_WaZOO)    /* resumed transfer? */
  2064.                     {
  2065.                         if (xfer_okay ())
  2066.                         {
  2067.                             j_status (MSG_TXT (M_RENAME_MSG), rxpathname);
  2068.                         }
  2069.                     }
  2070.  
  2071.                     if (rxftime > 0) /* utime doesn't like negative numbers */
  2072.                     {
  2073.                         struct utimbuf utimes;
  2074.  
  2075.                         utimes.UT_ACTIME = rxftime;
  2076.                         utimes.modtime = rxftime;
  2077.                         (void) utime (rxpathname, (UTIMBUF *) & utimes);
  2078.                     }
  2079.  
  2080.                     rxtime = through (&rxfsize, &rxstart);
  2081.                     rxfsize = rxpos - rxoffset;
  2082.                     j_status ("%s-H%s %s", MSG_TXT (M_FILE_RECEIVED), (txoptions & HOPT_CRC32) ? "/32" : " ", rxpathname);
  2083.                     j_msgend (Rx_y);
  2084.                     update_files (0, rxpathname, rxfsize, rxtime, 0);
  2085.  
  2086.                     rxstate = HRX_FINFO;
  2087.                     braindead = h_timer_set (H_BRAINDEAD);
  2088.                 }                /*skip/badeof/eof*/
  2089.             }                    /*rxstate==HRX_DATA*/
  2090.  
  2091.             if (rxstate == HRX_FINFO)
  2092.                 txpkt (0, HPKT_EOFACK);
  2093.             break;
  2094.  
  2095.             /*---------------------------------------------------*/
  2096.         case HPKT_EOFACK:
  2097.             if (txstate == HTX_EOF || txstate == HTX_EOFACK)
  2098.             {
  2099.                 braindead = h_timer_set (H_BRAINDEAD);
  2100.                 if (txfd >= 0)
  2101.                 {
  2102.                     long txtime;
  2103.  
  2104.                     close (txfd);
  2105.  
  2106.                     txfsize = txpos - txoffset;
  2107.                     txtime = through (&txfsize, &txstart);
  2108.                     j_status ("%s-H%s %s", MSG_TXT (M_FILE_SENT), (txoptions & HOPT_CRC32) ? "/32" : " ", txpathname);
  2109.                     j_msgend (Tx_y);
  2110.                     update_files (1, txpathname, txfsize, txtime, 0);
  2111.  
  2112.                     return (XFER_OK);
  2113.                 }
  2114.                 else
  2115.                     return (XFER_SKIP);
  2116.             }
  2117.             break;
  2118.  
  2119.             /*---------------------------------------------------*/
  2120.         case HPKT_IDLE:
  2121.             if (txstate == HTX_XWAIT)
  2122.             {
  2123.                 hdxlink = FALSE;
  2124.                 txtimer = h_timer_reset ();
  2125.                 txretries = 0;
  2126.                 txstate = HTX_XDATA;
  2127.             }
  2128.             else if (txstate >= HTX_FINFO && txstate < HTX_REND)
  2129.                 braindead = h_timer_set (H_BRAINDEAD);
  2130.             break;
  2131.  
  2132.             /*---------------------------------------------------*/
  2133.         case HPKT_END:
  2134.             if (txstate == HTX_END || txstate == HTX_ENDACK)
  2135.             {
  2136.                 txpkt (0, HPKT_END);
  2137.                 txpkt (0, HPKT_END);
  2138.                 txpkt (0, HPKT_END);
  2139. #ifdef DEBUG
  2140.                 j_status ("+HYDRA: Completed");
  2141. #endif
  2142.                 txstate = HTX_DONE;
  2143.                 res = XFER_OK;
  2144.             }
  2145.             break;
  2146.  
  2147. #ifdef HYDRADEV
  2148.             /*---------------------------------------------------*/
  2149.         case HPKT_DEVDATA:
  2150.             if (devrxid != intell (h_long1 (rxbuf)))
  2151.             {
  2152.                 hydra_devrecv ();
  2153.                 devrxid = intell (h_long1 (rxbuf));
  2154.             }
  2155.             h_long1 (txbufin) = h_long1 (rxbuf);    /*AGL:10feb93*/
  2156.             txpkt ((int) sizeof (long), HPKT_DEVDACK);
  2157.  
  2158.             break;
  2159.  
  2160.             /*---------------------------------------------------*/
  2161.         case HPKT_DEVDACK:
  2162.             if (devtxstate && (devtxid == intell (h_long1 (rxbuf))))
  2163.             {
  2164.                 devtxtimer = h_timer_reset ();
  2165.                 devtxstate = HTD_DONE;
  2166.             }
  2167.             break;
  2168. #endif
  2169.  
  2170.             /*---------------------------------------------------*/
  2171.         default:                /* unknown packet types: IGNORE, no error! */
  2172.             break;
  2173.  
  2174.             /*---------------------------------------------------*/
  2175.         }                        /*(pkttype)*/
  2176.  
  2177.         /*------------------------------------------------------*/
  2178.         switch (txstate)
  2179.         {
  2180.             /*---------------------------------------------------*/
  2181.         case HTX_START:
  2182.         case HTX_SWAIT:
  2183.             if (rxstate == HRX_FINFO)
  2184.             {
  2185.                 txtimer = h_timer_reset ();
  2186.                 txretries = 0;
  2187.                 txstate = HTX_INIT;
  2188.             }
  2189.             break;
  2190.  
  2191.             /*---------------------------------------------------*/
  2192.         case HTX_RINIT:
  2193.             if (rxstate == HRX_FINFO)
  2194.             {
  2195.                 txtimer = h_timer_reset ();
  2196.                 txretries = 0;
  2197.                 txstate = HTX_FINFO;
  2198.             }
  2199.             break;
  2200.  
  2201.             /*---------------------------------------------------*/
  2202.         case HTX_XDATA:
  2203.             if (rxstate && hdxlink)
  2204.             {
  2205.                 j_status (MSG_TXT (M_GOING_ONE_WAY));
  2206. #ifdef HYDRADEV
  2207.                 hydra_devsend ("MSG", (byte *) hdxmsg, (int) strlen (hdxmsg));
  2208. #endif
  2209.                 txtimer = h_timer_set (H_IDLE);
  2210.                 txstate = HTX_XWAIT;
  2211.             }
  2212.             break;
  2213.  
  2214.             /*---------------------------------------------------*/
  2215.         case HTX_XWAIT:
  2216.             if (!rxstate)
  2217.             {
  2218.                 txtimer = h_timer_reset ();
  2219.                 txretries = 0;
  2220.                 txstate = HTX_XDATA;
  2221.             }
  2222.             break;
  2223.  
  2224.             /*---------------------------------------------------*/
  2225.         case HTX_REND:
  2226. #ifdef HYDRADEV
  2227.             if (!rxstate && !devtxstate)
  2228. #else
  2229.             if (!rxstate)
  2230. #endif
  2231.             {
  2232.                 txtimer = h_timer_reset ();
  2233.                 txretries = 0;
  2234.                 txstate = HTX_END;
  2235.             }
  2236.             break;
  2237.  
  2238.             /*---------------------------------------------------*/
  2239.         default:                /* any other state - nothing to do */
  2240.             break;
  2241.  
  2242.         }                        /*switch(txstate)*/
  2243.  
  2244.     }
  2245.     while (txstate);
  2246.  
  2247.     if (txfd >= 0)
  2248.         close (txfd);
  2249.     hydra_badxfer ();
  2250.  
  2251.     if (res == XFER_ABORT)
  2252.     {
  2253.         CLEAR_OUTBOUND ();
  2254.         if (remote_capabilities)
  2255.             LOWER_DTR ();
  2256.         if (CARRIER)
  2257.         {
  2258.             braindead = h_timer_set (10);    /* wait max. 10s after abort */
  2259.             ComTXBlockTimeout (abortstr, (int) strlen (abortstr), braindead);
  2260.             while (!OUT_EMPTY () && CARRIER && !h_timer_expired (braindead, h_timer_get ()))
  2261.                 time_release ();
  2262.             CLEAR_OUTBOUND ();
  2263.         }
  2264.         CLEAR_INBOUND ();
  2265.         mail_finished = 0;
  2266.     }
  2267.     else
  2268.     {
  2269.         braindead = h_timer_set (10);    /* wait max. 10s after abort */
  2270.         while (!OUT_EMPTY () && CARRIER && !h_timer_expired (braindead, h_timer_get ()))
  2271.             time_release ();
  2272.     }
  2273.     return (res);
  2274. }                                /*hydra()*/
  2275.  
  2276. /* end of hydra.c */
  2277.